package aplicacion.modelo.gestores;

import aplicacion.modelo.*;
import java.util.*;
import org.jdom.*;
import org.jdom.input.*;
import org.jdom.output.*;
import java.io.*;

/** Clase Modelo Polígono.
 * Gestor encargado persistencia de datos de los polígonos, de recuperar y
 * almacenar la información de los polígonos en archivos XML, el cual recibe
 * la ruta del archivo dentro de los discos de respaldo del equipo.
 *
 * @author Ileana Natalia Díaz Palacios
 * Programación III
 * Universidad Nacional
 * 
 */
public class ManejadorCargaPoligonos {
    //<editor-fold defaultstate="collapsed" desc="Constructores">

    private ManejadorCargaPoligonos() {
        try {
            SAXBuilder constructor = new SAXBuilder(false);
            Document file = constructor.build("src//poligonomaker//configuracion//configuracion.xml");
            Element raiz = file.getRootElement();
            Element ruta = raiz.getChild("ruta");
            archivoEntrada = ruta.getChildText("path");
        } catch (Exception ex) {
            System.out.println(ex.toString());
        }
    }
    //</editor-fold>

    //<editor-fold defaultstate="collapsed" desc="Control de acceso">
    public static ManejadorCargaPoligonos obtenerInstancia() {
        if (instancia == null) {
            instancia = new ManejadorCargaPoligonos();
        }
        return instancia;
    }
    //</editor-fold>

    //<editor-fold defaultstate="collapsed" desc="Metodos de control de persistencia">
    public ArrayList<Poligono> cargarXML() {
        //Vector de poligonos a cargar
        ArrayList<Poligono> poligonos = new ArrayList<Poligono>();

        try {
            //Crear el contrutor arboles de datos
            SAXBuilder construtor = new SAXBuilder(false);
            //Crea un arbol de datos del archivo especificiado do en la ruta,
            //en caso de no existir el archivo tira una execpcion de flujo de datos
            Document archivo = construtor.build(archivoEntrada);
            //Se obtiene la raiz del arbol
            Element raiz = archivo.getRootElement();
            //Se obtiene la lista de hijos de la raiz
            List<Element> poligonosXML = raiz.getChildren("poligono");

            //Se recorrege la lista de hijos
            for (Element pivote : poligonosXML) {
                //Objectos para guardar los datos
                Poligono poligono = new Poligono();
                ArrayList<Punto> vertices = new ArrayList<Punto>();

                //Se obtiene el nombre
                poligono.setNombre(pivote.getChild("nombre").getText().toString());
                //Se Obtiene el tipo de relleno
                poligono.setTipoRelleno(Integer.parseInt(pivote.getChild("tipo").getText().toString()));

                //Carga los datos de color si el el tipo de relleno es 1
                if (poligono.getTipoRelleno() == 1) {
                    //String con el flujo de colores
                    String colores = pivote.getChild("color").getText().toString();
                    //Convierte el String que contiene los datos del color, en un vector.
                    StringTokenizer st = new StringTokenizer(colores, "-");
                    Integer[] color = new Integer[3];
                    for (int i = 0; i < 3; i++) {
                        color[i] = Integer.parseInt(st.nextToken());
                    }
                    poligono.setColor(color);
                }

                //Carga el dato del relleno si el el tipo de relleno es 2 ó 3
                if (poligono.getTipoRelleno() == 2 || poligono.getTipoRelleno() == 3) {
                    poligono.setRelleno(pivote.getChild("relleno").getText().toString());
                }

                //Carga la lista de puntos
                List<Element> puntosXML = pivote.getChild("puntos").getChildren("punto");
                for (Element puntoXML : puntosXML) {
                    //punto para guardar
                    Punto punto = new Punto();
                    //Convierte el String que contiene los datos del puntos, en un vector.
                    StringTokenizer st = new StringTokenizer(puntoXML.getText(), "-");
                    //Se guarda los puntos
                    punto.setPuntoX(Integer.parseInt(st.nextToken()));
                    punto.setPuntoY(Integer.parseInt(st.nextToken()));

                    //Se guarda el punto cargado
                    vertices.add(punto);
                }

                //Se cuarda el vector de puntos
                poligono.setVertices(vertices);

                //Se guarda el poligono cargado
                poligonos.add(poligono);

            }

        } catch (Exception e) {
            //Muestra errores
            System.out.println(e.getMessage());
            System.out.println(e.getStackTrace());
        }

        return poligonos;
    }

    public void guardarXML(String ruta, ArrayList<Poligono> poligonos) {
        try {
            //Crea un arbol de datos a gaurdar
            Document archivo = new Document();
            //Creamos la raiz del arbol de datos
            Element raiz = new Element("poligonos");

            //Recoremos el vector de poligonos a guardar
            for (Poligono pivote : poligonos) {
                //Creamos el nodo de poligono
                Element poligono = new Element("poligono");

                //Creamos el nodo de nombre
                Element nombre = new Element("nombre");
                //Ingresamos el dato del nodo de nombre
                nombre.setText(pivote.getNombre());
                //Agregamos el nodo nombre al nodo de poligono
                poligono.addContent(nombre);

                //Creamos el nodo de tipo
                Element tipo = new Element("tipo");
                //Ingresamos el dato del nodo de tipo
                tipo.setText(pivote.getTipoRelleno().toString());
                //Agregamos el nodo tipo al nodo de poligono
                poligono.addContent(tipo);

                //Creamos el nodo de color
                Element color = new Element("color");
                //Ingresamos el dato del nodo de color
                if (pivote.getTipoRelleno() == 1) {
                    Integer[] col = new Integer[3];
                    col[0] = pivote.getColor().getRed();
                    col[1] = pivote.getColor().getGreen();
                    col[2] = pivote.getColor().getBlue();
                    
                    String colString = col[0] + "-" + col[1] + "-" + col[2];
                    color.setText(colString);
                } else {
                    color.setText("");
                }
                //Agregamos el nodo color al nodo de poligono
                poligono.addContent(color);

                //Creamos el nodo de relleno
                Element relleno = new Element("relleno");
                //Ingresamos el dato del nodo de relleno
                relleno.setText(pivote.getRelleno());
                //Agregamos el nodo relleno al nodo de poligono
                poligono.addContent(relleno);

                //Creamos el nodo de puntos
                Element puntos = new Element("puntos");
                //Ingresamos los hijos del nodo de puntos
                for (Punto vertice : pivote.getVertices()) {
                    //Creamos el nodo de punto
                    Element punto = new Element("punto");
                    //Ingresamos el dato del nodo de punto
                    String textoPunto = vertice.getPuntoX().toString().concat("-").concat(vertice.getPuntoY().toString());
                    punto.setText(textoPunto);
                    //Agregamos el nodo punto al nodo padre
                    puntos.addContent(punto);
                }
                //Agregamos el nodo puntos al nodo de poligono
                poligono.addContent(puntos);

                //Agregamos el nodo de poligono al nodo raiz
                raiz.addContent(poligono);
            }

            //Agregamos la raiz al arbol de dato
            archivo.addContent(raiz);
            //Creamos el stream de salida
            FileOutputStream file_salida = new FileOutputStream(ruta);
            //Creamos el escritor del archivo XML
            XMLOutputter xml_salida = new XMLOutputter();
            //Escribimos el documento en el disco duro
            xml_salida.output(archivo, file_salida);
            // Cerramos el stream
            file_salida.close();

        } catch (Exception e) {
            //Muestra errores
            System.out.println(e.getMessage());
            System.out.println(e.getStackTrace());
        }
    }
    //</editor-fold>
    //<editor-fold defaultstate="collapsed" desc="Atributos">
    private static ManejadorCargaPoligonos instancia = null;
    private static String archivoEntrada = null;
    //</editor-fold>
}
